package com.intelligent.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.intelligent.dto.RolePageQueryDTO;
import com.intelligent.entity.Role;
import com.intelligent.mapper.TRoleMapper;
import com.intelligent.service.TRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
* @author lenovo
* @description 针对表【t_role(系统角色表)】的数据库操作Service实现
* @createDate 2025-08-26 17:05:13
*/
@Service
public class TRoleServiceImpl extends ServiceImpl<TRoleMapper, Role>
    implements TRoleService {

    @Autowired
    private TRoleMapper roleMapper;

    @Override
    public Map<String, Object> pageRoles(RolePageQueryDTO query) {
        long pageNum = query.getPageNum();
        long pageSize = query.getPageSize();
        String keyword = query.getKeyword();
        Integer status = query.getStatus();
        // 创建时间范围，仅使用 createTime 数组（大小为2）
        String beginTime = null;
        String endTime = null;
        if (query.getCreateTime() != null && query.getCreateTime().size() == 2) {
            beginTime = query.getCreateTime().get(0);
            endTime = query.getCreateTime().get(1);
            // 兼容仅传日期（yyyy-MM-dd）的情况
            if (beginTime != null && beginTime.length() == 10) {
                beginTime = beginTime + " 00:00:00";
            }
            if (endTime != null && endTime.length() == 10) {
                endTime = endTime + " 23:59:59";
            }
        }

        // 参数兜底与限流，防止 pageSize<=0 导致不分页
        if (pageNum < 1)
            pageNum = 1;
        if (pageSize < 1)
            pageSize = 10; // 默认页大小
        if (pageSize > 200)
            pageSize = 200; // 上限保护，避免大页拉全表

        Page<Role> page = new Page<>(pageNum, pageSize);
        LambdaQueryWrapper<Role> qw = new LambdaQueryWrapper<>();
        if (keyword != null && !keyword.isEmpty()) {
            qw.and(w -> w.like(Role::getRoleName, keyword)
                    .or().like(Role::getRoleCode, keyword)
                    .or().like(Role::getDescription, keyword));
        }
        if (status != null) {
            qw.eq(Role::getStatus, status);
        }



        this.page(page, qw);
        List<Role> records = page.getRecords();

        Map<String, Object> data = new HashMap<>();
        data.put("total", page.getTotal());
        data.put("records", records);
        return data;
    }

    @Override
    public void addRole(Role role) {
        // 1. 生成角色编码（JS + 3位数字序号）
        if (role.getRoleCode() == null || role.getRoleCode().isEmpty()) {
            // 查询当前最大的角色编码
            LambdaQueryWrapper<Role> qw = new LambdaQueryWrapper<>();
            qw.likeRight(Role::getRoleCode, "JS");
            qw.orderByDesc(Role::getRoleCode);
            qw.last("limit 1");
            Role maxCodeRole = this.getOne(qw);
            
            String newCode;
            if (maxCodeRole != null && maxCodeRole.getRoleCode() != null 
                    && maxCodeRole.getRoleCode().startsWith("JS") 
                    && maxCodeRole.getRoleCode().length() >= 5) {
                // 提取当前最大编码的数字部分
                String numStr = maxCodeRole.getRoleCode().substring(2);
                try {
                    int num = Integer.parseInt(numStr);
                    // 生成新编码：JS + 三位数字（不足补0）
                    newCode = String.format("JS%03d", num + 1);
                } catch (NumberFormatException e) {
                    // 如果解析失败，默认从001开始
                    newCode = "JS001";
                }
            } else {
                // 没有符合条件的编码，从001开始
                newCode = "JS001";
            }
            role.setRoleCode(newCode);
        }
        
        // 2. 校验角色名和角色编码唯一性
        checkRoleNameAndCodeUnique(role.getRoleName(), role.getRoleCode(), null);
        
        // 3. 设置默认值
        if (role.getStatus() == null) {
            role.setStatus(1); // 默认启用
        }
        if (role.getNumber() == null) {
            role.setNumber(0); // 默认人数为0
        }
        
        // 4. 保存角色
        this.save(role);
    }

    @Override
    public void updateRole(Role role) {
        if (role == null || role.getRoleId() == null) {
            throw new RuntimeException("参数错误：缺少角色ID");
        }
        
        // 1. 校验角色名和角色编码唯一性
        checkRoleNameAndCodeUnique(role.getRoleName(), role.getRoleCode(), role.getRoleId());
        
        // 2. 更新角色
        this.updateById(role);
    }

    @Override
    public void deleteRole(Long roleId) {
        if (roleId == null) {
            throw new RuntimeException("参数错误：缺少角色ID");
        }
        
        // 1. 检查角色是否被用户使用
        // TODO: 检查角色是否被用户使用，如果被使用则不允许删除
        
        // 2. 删除角色
        this.removeById(roleId);
    }
    
    /**
     * 校验角色名和角色编码唯一性
     * @param roleName 角色名
     * @param roleCode 角色编码
     * @param roleId 角色ID（更新时传入，新增时传null）
     */
    private void checkRoleNameAndCodeUnique(String roleName, String roleCode, Long roleId) {
        // 1. 校验角色名唯一性
        if (roleName != null && !roleName.isEmpty()) {
            LambdaQueryWrapper<Role> nameQw = new LambdaQueryWrapper<>();
            nameQw.eq(Role::getRoleName, roleName);
            if (roleId != null) {
                nameQw.ne(Role::getRoleId, roleId);
            }
            if (this.count(nameQw) > 0) {
                throw new RuntimeException("角色名已存在");
            }
        }
        
        // 2. 校验角色编码唯一性
        if (roleCode != null && !roleCode.isEmpty()) {
            LambdaQueryWrapper<Role> codeQw = new LambdaQueryWrapper<>();
            codeQw.eq(Role::getRoleCode, roleCode);
            if (roleId != null) {
                codeQw.ne(Role::getRoleId, roleId);
            }
            if (this.count(codeQw) > 0) {
                throw new RuntimeException("角色编码已存在");
            }
        }
    }
}




